"""
模拟数据管理器

用于模拟盘交易和回测的虚拟数据管理器
"""

import time
import random
from datetime import datetime, timedelta
from typing import Dict, List, Any, Optional
import pandas as pd
from ..core import unified_logger


class MockDataManager:
    """模拟数据管理器"""
    
    def __init__(self, config: Dict[str, Any]):
        """
        初始化模拟数据管理器
        
        Args:
            config: 配置信息
        """
        self.config = config
        self.logger = unified_logger.get_logger('mock_data_manager')
        
        # 虚拟价格数据
        self.price_data = {}
        self.base_prices = {}
        self.price_volatility = config.get('price_volatility', 0.02)  # 价格波动率
        
        # 初始化基础价格
        self._init_base_prices()
        
        self.logger.info("模拟数据管理器初始化完成")
    
    def _init_base_prices(self) -> None:
        """初始化基础价格"""
        # 常见交易对的基础价格
        default_prices = {
            'BTC-USDT': 45000.0,
            'ETH-USDT': 3000.0,
            'BNB-USDT': 300.0,
            'ADA-USDT': 0.5,
            'SOL-USDT': 100.0,
            'DOT-USDT': 7.0,
            'MATIC-USDT': 0.8,
            'LINK-USDT': 15.0,
            'UNI-USDT': 6.0,
            'AVAX-USDT': 35.0
        }
        
        # 从配置中获取自定义价格，否则使用默认价格
        custom_prices = self.config.get('base_prices', {})
        self.base_prices.update(default_prices)
        self.base_prices.update(custom_prices)
        
        # 初始化当前价格
        for symbol, price in self.base_prices.items():
            self.price_data[symbol] = {
                'current_price': price,
                'last_update': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),  # 统一格式
                'price_history': [price]
            }
    
    def set_base_price(self, symbol: str, price: float) -> None:
        """
        设置基础价格
        
        Args:
            symbol: 交易对
            price: 基础价格
        """
        self.base_prices[symbol] = price
        if symbol not in self.price_data:
            self.price_data[symbol] = {
                'current_price': price,
                'last_update': datetime.now(),  # 使用datetime对象
                'price_history': [price]
            }
        else:
            self.price_data[symbol]['current_price'] = price
            self.price_data[symbol]['last_update'] = datetime.now()  # 使用datetime对象
            self.price_data[symbol]['price_history'].append(price)
        
        self.logger.info(f"设置基础价格: {symbol} = {price}")

    def get_latest_price(self, exchange: str, symbol: str) -> Optional[float]:
        """
        获取最新价格（虚拟价格）
        
        Args:
            exchange: 交易所名称（忽略）
            symbol: 交易对
            
        Returns:
            最新价格
        """
        if symbol not in self.price_data:
            # 如果没有该交易对，尝试生成一个默认价格
            if 'USDT' in symbol:
                base_asset = symbol.replace('-USDT', '').replace('USDT', '')
                if base_asset in ['BTC', 'BITCOIN']:
                    default_price = 45000.0
                elif base_asset in ['ETH', 'ETHEREUM']:
                    default_price = 3000.0
                else:
                    default_price = random.uniform(1.0, 100.0)
                
                self.set_base_price(symbol, default_price)
            else:
                return None
        
        # 生成价格波动
        current_data = self.price_data[symbol]
        base_price = current_data['current_price']
        
        # 基于时间的价格波动
        now = datetime.now()
        # 确保last_update是datetime对象
        last_update = current_data['last_update']
        if isinstance(last_update, str):
            last_update = datetime.strptime(last_update, '%Y-%m-%d %H:%M:%S')
        
        time_diff = (now - last_update).total_seconds()
        
        if time_diff > 1:  # 每秒更新一次价格
            # 生成随机波动
            volatility = self.price_volatility
            change_percent = random.uniform(-volatility, volatility)
            new_price = base_price * (1 + change_percent)
            
            # 确保价格不会变成负数或过小
            new_price = max(new_price, base_price * 0.5)
            
            # 更新价格数据
            current_data['current_price'] = new_price
            current_data['last_update'] = now
            current_data['price_history'].append(new_price)
            
            # 限制历史数据长度
            if len(current_data['price_history']) > 1000:
                current_data['price_history'] = current_data['price_history'][-500:]
        
        return current_data['current_price']
    
    def get_kline_data(self, exchange: str, market_type: str, symbol: str, 
                      period: str, start_time: Optional[int] = None, 
                      end_time: Optional[int] = None, 
                      use_cache: bool = True) -> Optional[pd.DataFrame]:
        """
        获取K线数据（生成虚拟数据）
        
        Args:
            exchange: 交易所名称
            market_type: 市场类型
            symbol: 交易对
            period: 时间周期
            start_time: 开始时间
            end_time: 结束时间
            use_cache: 是否使用缓存
            
        Returns:
            K线数据
        """
        try:
            # 获取基础价格
            base_price = self.base_prices.get(symbol, 100.0)
            
            # 解析时间周期
            period_minutes = self._parse_period(period)
            
            # 生成时间序列
            if end_time is None:
                end_time = int(datetime.now().timestamp())
            if start_time is None:
                start_time = end_time - 86400  # 默认1天数据
            
            timestamps = []
            current_time = start_time
            while current_time < end_time:
                timestamps.append(current_time)
                current_time += period_minutes * 60
            
            # 生成K线数据
            klines = []
            current_price = base_price
            
            for ts in timestamps:
                # 生成OHLCV数据
                open_price = current_price
                
                # 生成价格波动
                volatility = self.price_volatility
                high_change = random.uniform(0, volatility)
                low_change = random.uniform(-volatility, 0)
                close_change = random.uniform(-volatility/2, volatility/2)
                
                high_price = open_price * (1 + high_change)
                low_price = open_price * (1 + low_change)
                close_price = open_price * (1 + close_change)
                
                # 确保OHLC逻辑正确
                high_price = max(high_price, open_price, close_price)
                low_price = min(low_price, open_price, close_price)
                
                # 生成成交量
                volume = random.uniform(100, 10000)
                
                klines.append({
                    'timestamp': ts,
                    'datetime': datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S'),
                    'open': round(open_price, 4),
                    'high': round(high_price, 4),
                    'low': round(low_price, 4),
                    'close': round(close_price, 4),
                    'volume': round(volume, 2)
                })
                
                current_price = close_price
            
            df = pd.DataFrame(klines)
            return df
            
        except Exception as e:
            self.logger.error(f"生成K线数据失败: {e}")
            return None
    
    def _parse_period(self, period: str) -> int:
        """
        解析时间周期为分钟数
        
        Args:
            period: 时间周期字符串
            
        Returns:
            分钟数
        """
        period_map = {
            '1m': 1,
            '3m': 3,
            '5m': 5,
            '15m': 15,
            '30m': 30,
            '1h': 60,
            '2h': 120,
            '4h': 240,
            '6h': 360,
            '8h': 480,
            '12h': 720,
            '1d': 1440,
            '3d': 4320,
            '1w': 10080
        }
        
        return period_map.get(period, 5)  # 默认5分钟
    
    def register_exchange(self, exchange_name: str, exchange_adapter):
        """
        注册交易所（模拟实现）
        
        Args:
            exchange_name: 交易所名称
            exchange_adapter: 交易所适配器
        """
        self.logger.info(f"注册模拟交易所: {exchange_name}")
    
    def update_data(self, exchange: str, market_type: str, symbol: str, 
                   period: str, force_update: bool = False) -> bool:
        """
        更新数据（模拟实现）
        
        Args:
            exchange: 交易所名称
            market_type: 市场类型
            symbol: 交易对
            period: 时间周期
            force_update: 是否强制更新
            
        Returns:
            是否更新成功
        """
        self.logger.info(f"模拟更新数据: {exchange} {symbol} {period}")
        return True
    
    def get_historical_data(self, symbol: str, hours: int = 24) -> List[Dict[str, Any]]:
        """
        获取历史数据
        
        Args:
            symbol: 交易对
            hours: 小时数
            
        Returns:
            历史数据列表
        """
        base_price = self.base_prices.get(symbol, 100.0)
        
        # 生成虚拟价格数据
        data = []
        now = datetime.now()
        
        # 生成过去24小时的数据
        for i in range(hours):
            timestamp = now - timedelta(hours=i)
            price = base_price * (1 + random.uniform(-0.05, 0.05))  # ±5%波动
            
            data.append({
                'symbol': symbol,
                'price': price,
                'timestamp': timestamp.strftime('%Y-%m-%d %H:%M:%S'),  # 统一格式
                'volume': random.uniform(1000, 10000)
            })
        
        return data
    
    def get_data_stats(self) -> Dict[str, Any]:
        """
        获取数据统计信息
        
        Returns:
            数据统计信息
        """
        return {
            'symbols': list(self.price_data.keys()),
            'total_symbols': len(self.price_data),
            'last_update': datetime.now().strftime('%Y-%m-%d %H:%M:%S')  # 统一格式
        }